{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "7. Antiderivative(DeepOnets).ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "machine_shape": "hm",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/jdtoscano94/Learning-PINNs-in-Python-Physics-Informed-Machine-Learning/blob/main/7_Antiderivative(DeepOnets).ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7JQXTWz35c40"
      },
      "outputs": [],
      "source": [
        "import numpy as onp\n",
        "import jax.numpy as np\n",
        "from jax import random, grad, vmap, jit\n",
        "from jax.experimental import optimizers\n",
        "from jax.experimental.ode import odeint\n",
        "from jax.nn import relu\n",
        "from jax.config import config\n",
        "\n",
        "import itertools\n",
        "from functools import partial\n",
        "from torch.utils import data\n",
        "from tqdm import trange\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "%matplotlib inline"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Auxiliary Functions"
      ],
      "metadata": {
        "id": "fDhK-Kr3GyGa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define RBF kernel\n",
        "def RBF(x1, x2, params):\n",
        "    output_scale, lengthscales = params\n",
        "    diffs = np.expand_dims(x1 / lengthscales, 1) - \\\n",
        "            np.expand_dims(x2 / lengthscales, 0)\n",
        "    r2 = np.sum(diffs**2, axis=2)\n",
        "    return output_scale * np.exp(-0.5 * r2)"
      ],
      "metadata": {
        "id": "rT2DnjCLG3cv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def plot_us(x,u,y,s):\n",
        "  fig, ax1 = plt.subplots(figsize=(8, 6))\n",
        "  plt.rcParams['font.size'] = '18'\n",
        "  color='black'\n",
        "  wdt=1.5\n",
        "  ax1.plot(x,u,'k--',label='$u(x)=ds/dx$',linewidth=wdt)\n",
        "  ax1.plot(y,s,'o-',label='$s(x)=s(0)+\\int u(t)dt|_{t=y}$',linewidth=wdt)\n",
        "  ax1.set_xlabel('x',fontsize='large')\n",
        "  ax1.set_ylabel('u',fontsize='large')\n",
        "  ax1.tick_params(axis='y', color=color)\n",
        "  ax1.legend(loc = 'lower right', ncol=1)"
      ],
      "metadata": {
        "id": "IVsow-L9Gz2b"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Introduction**\n",
        "\n",
        "## **Functions and Operators:**\n",
        "\n",
        "### **Function:**\n",
        "\n",
        " Maps between vector spaces:\n",
        "\n",
        "*Example:*\n",
        "\n",
        "Let $f_1(x)=sin(x)$; for  $x\\in\\mathbf{R}$\n",
        "\n",
        "$$z=f_1(x)=sin(x)\\in[0:1]$$\n",
        "\n",
        "In other words $f_1$ maps $\\mathbf{R}→[0,1]$\n",
        "\n",
        "### **Operator:**\n",
        "\n",
        " Maps between infite-dimensional function spaces:\n",
        "$$G(f_1(x))=f_2(x)$$\n",
        "\n",
        "*Example:*\n",
        "\n",
        "Derivative Operator →$\\frac{d}{d x}$\n",
        "\n",
        "It transforms a funcion $f_1$ into a function $f_2$:\n",
        "\n",
        "Let $f_1(x)=sin(x)$\n",
        "\n",
        "Then when we apply our operator:\n",
        "\n",
        "$$f_2=\\frac{df_1(x)}{d x}=\\frac{d}{d x}sin(x)=cos(x)$$\n",
        "\n",
        "\n",
        "### **Parametric PDEs and Operators**\n",
        "\n",
        "Parametric PDEs $\\rightarrow$ Some parameters (e.g., shape, IC/BC, coefficients, etc.) of a given PDE system are allowed to change.\n",
        "\n",
        "Let  $\\mathcal{N}$ be a nonlinear operator. Let's consider a parametric PDEs of the form:\n",
        "\n",
        "$$\\mathcal{N}(u,s)=0$$\n",
        "\n",
        "Where $u$ is the input function and $s$ is the unknown PDE's solution (also a function).\n",
        "\n",
        "Our PDE solution operator would be:\n",
        "\n",
        "$$G(u)=s$$\n",
        "\n",
        "**Note 1:**I other words, we can express the general solution of our PDE as an operator $G$\n",
        "\n",
        "**Note 2:** Remember $s$ is itself a function, so if we evaluate it at any point $y$, the answer would be a real number:\n",
        "\n",
        " $$G(u)(y)=s(y)\\in \\mathbf{R}$$\n",
        "\n",
        " ### **Universal Approximation Theorem for Operator**\n",
        "\n",
        " $\\forall \\epsilon >0$, there are positive integers $n,p,m$, constants $c_i^k,W_{bij}^k,b_{bij}^k,W_{tk},b_{tk}$ such that:\n",
        "\n",
        "$$\\left|G(u)(y)-\\sum_{k=1}^{p}\\sum_{i=1}^{n}c_i^k\\sigma\\left(\\sum_{j=1}^{m}W_{bij}^{k}u(x_j)+b_{bi}^k\\right).\\sigma(W_{tk}.y+b_{tk})\\right|<\\epsilon $$\n",
        "\n",
        " ### **Neural Network**\n",
        "\n",
        "A Neural Network is a function that takes the form: (See:https://book.sciml.ai/notes/03/)\n",
        "\n",
        "$$NN(X)=W_n\\sigma_{n-1}(W_{n-1}\\sigma_{n-2}(...(W_2\\sigma_1(W_1X+b_1)+b_2)+..)+b_{n-1})+b_n$$\n",
        "\n",
        "So we can use 2 NNs to implement the Universal Approximation Theorem for Operator i.e.:\n",
        "\n",
        "Branch:\n",
        "\n",
        "$$NN_b(u(\\textbf{x}))=b(u(\\textbf{x}))=\\textbf{c}.\\sigma\\left(W_{b}u(\\textbf{x})+\\textbf{b}_{b}\\right)$$\n",
        "\n",
        "Trunk:\n",
        "\n",
        "\n",
        "$$NN_t(\\textbf{y})=t(\\textbf{y})=\\sigma(W_{t}.\\textbf{y}+\\textbf{b}_{t})$$\n",
        "\n",
        "### **DeepOnet**\n",
        "\n",
        "Learn the solution operators of parametric PDEs → We will try to approximate $G$  (the solution of our PDE operator) by two neural networks:\n",
        "\n",
        "\n",
        "$$G_\\theta(u)(y)=\\sum_{k=1}^q\\underset{Branch}{\\underbrace{b_k\\left(u(x_1),u(x_2),...,u(x_m)\\right)}}.\\underset{Trunk}{\\underbrace{t_k(\\textbf{y})}}$$\n",
        "\n",
        "\n",
        "We want to obtain G, so our goal would be:\n",
        "\n",
        " $$G_\\theta(u)(y)\\approx G(u)(y)$$\n",
        "\n",
        "So we will enforce that condition into a loss function:\n",
        "\n",
        "$$\\mathcal{L}(\\theta)=\\frac{1}{NP}\\sum_{i=1}^N\\sum_{j=1}^P\\left|G_{\\theta}(u^{(i)})y_j^{(i)}-G(u^{(i)})y_j^{(i)}\\right|^2$$\n",
        "\n",
        "\n",
        "$$\\mathcal{L}(\\theta)=\\frac{1}{NP}\\sum_{i=1}^N\\sum_{j=1}^P\\left|\\sum_{k=1}^q{b_k\\left(u(x_1),u(x_2),...,u(x_m)\\right)}.t_k(y_j^{(i)})-G(u^{(i)})y_j^{(i)}\\right|^2$$\n",
        "\n",
        "where $N$ is the number of functions $u(x)$ in our training dataset, $P$, is the number of points inside the domain at which we will evaluate $G(u)$. \n",
        "\n",
        "$m:$ Number of points at which we evaluated our input functions.\n",
        "\n",
        "$N:$ Number of input functions.\n",
        "\n",
        "$P:$ Number of points at which we evaluate the output function → output sensors.\n"
      ],
      "metadata": {
        "id": "PhPIO4gwxTcb"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**In summary:**\n",
        "\n",
        "To train a DeepOnet, we would:\n",
        "\n",
        "1.   We select $N$ functions →$u(x)$.\n",
        "2.   We evaluate our $N$ functions at $m$ points (i.e., input sensors) →$u(x_1),u(x_2),...,u(x_m)$\n",
        "3.   We send the $m$ outputs of our $N$ functions to our **branch network** → $b_k(u(x_1),u(x_2),...,u(x_m))$\n",
        "4.   We select $P$ points (i.e., output sensors) inside our domain → $y_1,y_2,...,y_P$\n",
        "5.  We send our output sensors to our **trunk network**→$t_k(y_1,y_2,...,y_P)$\n",
        "6. We approximate our operator by computing the dot product between the outpur of our **branch network** and the output of our **trunk network**→ $G_\\theta(u)(y)=\\sum_{k=1}^q\\underset{Branch}{\\underbrace{b_k\\left(u(x_1),u(x_2),...,u(x_m)\\right)}}.\\underset{Trunk}{\\underbrace{t_k(\\textbf{y})}}$\n",
        "7. Ideally $G_\\theta(u)(y)\\approx G(u)(y)$, so we compute the error → $\\mathcal{L}(\\theta)=\\frac{1}{NP}\\sum_{i=1}^N\\sum_{j=1}^P\\left|G_{\\theta}(u^{(i)})y_j^{(i)}-G(u^{(i)})y_j^{(i)}\\right|^2$\n",
        "\n",
        "8. We update our NN parameters (i.e., branch and trunk) to minimize  $\\mathcal{L}(\\theta)$.\n",
        "9. We repeat the process."
      ],
      "metadata": {
        "id": "4-o-HC2x4T9L"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Problem Setup\n",
        "\n",
        "**Anti-derivative Operator**\n",
        "\n",
        "Our PDE would be:\n",
        "\n",
        "$$\\frac{ds(x)}{dx}-u(x)=0$$\n",
        "\n",
        "\n",
        "The solution of our PDE is:\n",
        "\n",
        "$$G:u(x)→s(x)=s(0)+\\int_{0}^{x}u(t)dt$$\n",
        "\n",
        "$$x\\in[0,1]$$\n",
        "$$s(0)=0$$"
      ],
      "metadata": {
        "id": "J-qnbwQ5DTuw"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Data Generation"
      ],
      "metadata": {
        "id": "FvY9PrxfylwH"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "We will randomly sample 10000 different functions $u$ from a zero-mean Gaussian process with an exponential quadratic kernel with a length scale: $l=0.2$."
      ],
      "metadata": {
        "id": "phC4C1GNDrvA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "N_train = 10000\n",
        "m = 100 # number of input sensors\n",
        "P_train = 1   # number of output sensors\n",
        "length_scale = 0.2 #lenght_scale for the exponential quadratic kernel\n",
        "key_train = random.PRNGKey(0)  # use different key for generating training data and test data \n",
        "config.update(\"jax_enable_x64\", True) # Enable double precision"
      ],
      "metadata": {
        "id": "R-lQbo2kYcvA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Generate a random function"
      ],
      "metadata": {
        "id": "gupNZ3GKDSDu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Sample GP prior at a fine grid\n",
        "N = 512\n",
        "gp_params = (1.0, length_scale)\n",
        "jitter = 1e-10\n",
        "X = np.linspace(0, 1, N)[:,None]\n",
        "K = RBF(X, X, gp_params)\n",
        "L = np.linalg.cholesky(K + jitter*np.eye(N))\n",
        "gp_sample = np.dot(L, random.normal(key_train, (N,)))\n",
        "\n",
        "# Create a callable interpolation function  \n",
        "u_fn = lambda x, t: np.interp(t, X.flatten(), gp_sample)\n",
        "# Input sensor locations and measurements\n",
        "x = np.linspace(0, 1, m)\n",
        "u = vmap(u_fn, in_axes=(None,0))(0.0, x) #vectorize our code to run it in multiple batches simultaneusly (or to evaluate a function simultaneusly)"
      ],
      "metadata": {
        "id": "ol-umrOeGD0E"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We obtain the corresponding 10000 ODE solutions by solving: \n",
        "\n",
        "$$\\frac{ds(x)}{dx}=u(x)$$\n",
        "\n",
        "Using an explicit Runge-Kutta method(RK45)→ JAX's odeint functiom."
      ],
      "metadata": {
        "id": "XHzsz9XlEzCy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Output sensor locations and measurements\n",
        "y_train = random.uniform(key_train, (P_train*100,)).sort() \n",
        "s_train = odeint(u_fn, 0.0, y_train) # Obtain the ODE solution"
      ],
      "metadata": {
        "id": "Y6-OyfHJl0-7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plot_us(x,u,y_train,s_train)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 400
        },
        "id": "kTiLiL5gK917",
        "outputId": "6480d812-f687-4f8e-d762-e31d8b67204c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 576x432 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now, we will have to create many functions for our testing and training dataset, so let's create a pair of programing-functions to generate one random function at a time."
      ],
      "metadata": {
        "id": "0BJmeBjxfjjg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Geneate training data corresponding to one input sample\n",
        "def generate_one_training_data(key, m=100, P=1):\n",
        "    # Sample GP prior at a fine grid\n",
        "    N = 512\n",
        "    gp_params = (1.0, length_scale)\n",
        "    jitter = 1e-10\n",
        "    X = np.linspace(0, 1, N)[:,None]\n",
        "    K = RBF(X, X, gp_params)\n",
        "    L = np.linalg.cholesky(K + jitter*np.eye(N))\n",
        "    gp_sample = np.dot(L, random.normal(key, (N,)))\n",
        "\n",
        "    # Create a callable interpolation function  \n",
        "    u_fn = lambda x, t: np.interp(t, X.flatten(), gp_sample)\n",
        "\n",
        "    # Input sensor locations and measurements\n",
        "    x = np.linspace(0, 1, m)\n",
        "    u = vmap(u_fn, in_axes=(None,0))(0.0, x)\n",
        "\n",
        "    # Output sensor locations and measurements\n",
        "    y_train = random.uniform(key, (P,)).sort() \n",
        "    s_train = odeint(u_fn, 0.0, np.hstack((0.0, y_train)))[1:] # JAX has a bug and always returns s(0), so add a dummy entry to y and return s[1:]\n",
        "\n",
        "    # Tile inputs\n",
        "    u_train = np.tile(u, (P,1))\n",
        "\n",
        "    return u_train, y_train, s_train\n"
      ],
      "metadata": {
        "id": "aS4wnXKpzHic"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Geneate test data corresponding to one input sample\n",
        "def generate_one_test_data(key, m=100, P=100):\n",
        "    # Sample GP prior at a fine grid\n",
        "    N = 512\n",
        "    gp_params = (1.0, length_scale)\n",
        "    jitter = 1e-10\n",
        "    X = np.linspace(0, 1, N)[:,None]\n",
        "    K = RBF(X, X, gp_params)\n",
        "    L = np.linalg.cholesky(K + jitter*np.eye(N))\n",
        "    gp_sample = np.dot(L, random.normal(key, (N,)))\n",
        "\n",
        "    # Create a callable interpolation function  \n",
        "    u_fn = lambda x, t: np.interp(t, X.flatten(), gp_sample)\n",
        "\n",
        "    # Input sensor locations and measurements\n",
        "    x = np.linspace(0, 1, m)\n",
        "    u = vmap(u_fn, in_axes=(None,0))(0.0, x)\n",
        "\n",
        "    # Output sensor locations and measurements\n",
        "    y = np.linspace(0, 1, P)\n",
        "    s = odeint(u_fn, 0.0, y)\n",
        "\n",
        "    # Tile inputs\n",
        "    u = np.tile(u, (P,1))\n",
        "\n",
        "    return u, y, s "
      ],
      "metadata": {
        "id": "Bhn_Dy-FWph0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Data Generation"
      ],
      "metadata": {
        "id": "rx2GnFcxy2vq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Training Data\n",
        "N_train = 10000 #Number of functions\n",
        "m = 100 # number of input sensors\n",
        "P_train = 1   # number of output sensors\n",
        "key_train = random.PRNGKey(0)  # use different key for generating training data and test data "
      ],
      "metadata": {
        "id": "dKqeYeFVbmEJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "config.update(\"jax_enable_x64\", True) # Enable double precision\n",
        "keys = random.split(key_train, N_train) # Obtain 10000 random numbers"
      ],
      "metadata": {
        "id": "LctcnSb_hVr2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "gen_fn = jit(lambda key: generate_one_training_data(key, m, P_train)) #lets call our function\n",
        "u_train, y_train, s_train = vmap(gen_fn)(keys)"
      ],
      "metadata": {
        "id": "CZCfAP7Qha8N"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Reshape the data\n",
        "u_train = np.float32(u_train.reshape(N_train * P_train,-1))\n",
        "y_train = np.float32(y_train.reshape(N_train * P_train,-1))\n",
        "s_train = np.float32(s_train.reshape(N_train * P_train,-1))"
      ],
      "metadata": {
        "id": "PrIKONnAiLBs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Testing Data\n",
        "N_test = 1 # number of input samples \n",
        "P_test = m   # number of sensors \n",
        "key_test = random.PRNGKey(12345) # A different key "
      ],
      "metadata": {
        "id": "t72zeQnJirdA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "keys = random.split(key_test, N_test)\n",
        "gen_fn = jit(lambda key: generate_one_test_data(key, m, P_test))\n",
        "u, y, s = vmap(gen_fn)(keys)"
      ],
      "metadata": {
        "id": "EfTydf5Cjkrh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Reshape the data\n",
        "u_test = np.float32(u.reshape(N_test * P_test,-1))\n",
        "y_test = np.float32(y.reshape(N_test * P_test,-1))\n",
        "s_test = np.float32(s.reshape(N_test * P_test,-1))"
      ],
      "metadata": {
        "id": "O_cXqtdFjo57"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Data generator\n",
        "class DataGenerator(data.Dataset):\n",
        "    def __init__(self, u, y, s, \n",
        "                 batch_size=64, rng_key=random.PRNGKey(1234)):\n",
        "        'Initialization'\n",
        "        self.u = u # input sample\n",
        "        self.y = y # location\n",
        "        self.s = s # labeled data evulated at y (solution measurements, BC/IC conditions, etc.)\n",
        "        \n",
        "        self.N = u.shape[0]\n",
        "        self.batch_size = batch_size\n",
        "        self.key = rng_key\n",
        "\n",
        "    def __getitem__(self, index):\n",
        "        'Generate one batch of data'\n",
        "        self.key, subkey = random.split(self.key)\n",
        "        inputs, outputs = self.__data_generation(subkey)\n",
        "        return inputs, outputs\n",
        "\n",
        "    @partial(jit, static_argnums=(0,))\n",
        "    def __data_generation(self, key):\n",
        "        'Generates data containing batch_size samples'\n",
        "        idx = random.choice(key, self.N, (self.batch_size,), replace=False)\n",
        "        s = self.s[idx,:]\n",
        "        y = self.y[idx,:]\n",
        "        u = self.u[idx,:]\n",
        "        # Construct batch\n",
        "        inputs = (u, y)\n",
        "        outputs = s\n",
        "        return inputs, outputs"
      ],
      "metadata": {
        "id": "fm6kLyH0lev8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# DeepOnet"
      ],
      "metadata": {
        "id": "GfgoQuM6lKTa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the neural net\n",
        "def MLP(layers, activation=relu):\n",
        "  ''' Vanilla MLP'''\n",
        "  def init(rng_key):\n",
        "      def init_layer(key, d_in, d_out):\n",
        "          k1, k2 = random.split(key)\n",
        "          glorot_stddev = 1. / np.sqrt((d_in + d_out) / 2.)\n",
        "          W = glorot_stddev * random.normal(k1, (d_in, d_out))\n",
        "          b = np.zeros(d_out)\n",
        "          return W, b\n",
        "      key, *keys = random.split(rng_key, len(layers))\n",
        "      params = list(map(init_layer, keys, layers[:-1], layers[1:]))\n",
        "      return params\n",
        "  def apply(params, inputs):\n",
        "      for W, b in params[:-1]:\n",
        "          outputs = np.dot(inputs, W) + b\n",
        "          inputs = activation(outputs)\n",
        "      W, b = params[-1]\n",
        "      outputs = np.dot(inputs, W) + b\n",
        "      return outputs\n",
        "  return init, apply"
      ],
      "metadata": {
        "id": "Jslem3iHlwAs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the model\n",
        "class DeepONet:\n",
        "    def __init__(self, branch_layers, trunk_layers):    \n",
        "        # Network initialization and evaluation functions\n",
        "        self.branch_init, self.branch_apply = MLP(branch_layers, activation=relu)\n",
        "        self.trunk_init, self.trunk_apply = MLP(trunk_layers, activation=relu)\n",
        "\n",
        "        # Initialize\n",
        "        branch_params = self.branch_init(rng_key = random.PRNGKey(1234))\n",
        "        trunk_params = self.trunk_init(rng_key = random.PRNGKey(4321))\n",
        "        params = (branch_params, trunk_params)\n",
        "\n",
        "        # Use optimizers to set optimizer initialization and update functions\n",
        "        self.opt_init, \\\n",
        "        self.opt_update, \\\n",
        "        self.get_params = optimizers.adam(optimizers.exponential_decay(1e-3, \n",
        "                                                                      decay_steps=1000, \n",
        "                                                                      decay_rate=0.9))\n",
        "        self.opt_state = self.opt_init(params)\n",
        "\n",
        "        self.itercount = itertools.count()\n",
        "        # Logger\n",
        "        self.loss_log = []\n",
        "\n",
        "    # Define opeartor net\n",
        "    def operator_net(self, params, u, y):\n",
        "        branch_params, trunk_params = params\n",
        "        B = self.branch_apply(branch_params, u)\n",
        "        T = self.trunk_apply(trunk_params, y)\n",
        "        outputs = np.sum(B * T)\n",
        "        return outputs\n",
        "      \n",
        "    # Define ODE/PDE residual\n",
        "    def residual_net(self, params, u, y):\n",
        "        s_y = grad(self.operator_net, argnums = 2)(params, u, y)\n",
        "        return s_y\n",
        "\n",
        "    # Define loss\n",
        "    def loss(self, params, batch):\n",
        "        # Fetch data\n",
        "        # inputs: (u, y), shape = (N, m), (N,1)\n",
        "        # outputs: s, shape = (N,1)\n",
        "        inputs, outputs = batch\n",
        "        u, y = inputs\n",
        "        # Compute forward pass\n",
        "        pred = vmap(self.operator_net, (None, 0, 0))(params, u, y)\n",
        "        # Compute loss\n",
        "        loss = np.mean((outputs.flatten() - pred)**2)\n",
        "        return loss\n",
        "\n",
        "    # Define a compiled update step\n",
        "    @partial(jit, static_argnums=(0,))\n",
        "    def step(self, i, opt_state, batch):\n",
        "        params = self.get_params(opt_state)\n",
        "        g = grad(self.loss)(params, batch)\n",
        "        return self.opt_update(i, g, opt_state)\n",
        "\n",
        "    # Optimize parameters in a loop\n",
        "    def train(self, dataset, nIter = 10000):\n",
        "        data = iter(dataset)\n",
        "        pbar = trange(nIter)\n",
        "        # Main training loop\n",
        "        for it in pbar:\n",
        "            batch = next(data)\n",
        "            self.opt_state = self.step(next(self.itercount), self.opt_state, batch)\n",
        "            \n",
        "            if it % 100 == 0:\n",
        "                params = self.get_params(self.opt_state)\n",
        "\n",
        "                # Compute loss\n",
        "                loss_value = self.loss(params, batch)\n",
        "\n",
        "                # Store loss\n",
        "                self.loss_log.append(loss_value)\n",
        "\n",
        "                # Print loss during training\n",
        "                pbar.set_postfix({'Loss': loss_value})\n",
        "       \n",
        "    # Evaluates predictions at test points  \n",
        "    @partial(jit, static_argnums=(0,))\n",
        "    def predict_s(self, params, U_star, Y_star):\n",
        "        s_pred = vmap(self.operator_net, (None, 0, 0))(params, U_star, Y_star)\n",
        "        return s_pred\n",
        "\n",
        "    @partial(jit, static_argnums=(0,))\n",
        "    def predict_s_y(self, params, U_star, Y_star):\n",
        "        s_y_pred = vmap(self.residual_net, (None, 0, 0))(params, U_star, Y_star)\n",
        "        return s_y_pred"
      ],
      "metadata": {
        "id": "7ZG1bVnij-bg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Evaluate our Operator"
      ],
      "metadata": {
        "id": "p1bmvbf1rTx2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Initialize model\n",
        "# For vanilla DeepONet, shallower network yields better accuarcy.\n",
        "branch_layers = [100, 100, 100] \n",
        "trunk_layers =  [1, 100, 100]\n",
        "\n",
        "model = DeepONet(branch_layers, trunk_layers)"
      ],
      "metadata": {
        "id": "X5RUVLmalT4P"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Create data set\n",
        "batch_size = 10000\n",
        "dataset = DataGenerator(u_train, y_train, s_train, batch_size)"
      ],
      "metadata": {
        "id": "vrXXP3ztlun6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Train\n",
        "model.train(dataset, nIter=40000)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mUDa7cAdl9wR",
        "outputId": "90d38e9a-379c-409e-8e74-935ee0ddce20"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 40000/40000 [01:23<00:00, 479.27it/s, Loss=4.895145844785917e-07]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Predict\n",
        "params = model.get_params(model.opt_state)"
      ],
      "metadata": {
        "id": "eXwnbxoQmR5w"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "s_pred = model.predict_s(params, u_test, y_test)[:,None]"
      ],
      "metadata": {
        "id": "-nO5cCL6mV-F"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "s_y_pred = model.predict_s_y(params, u_test, y_test) # remember that s_y=ds/dy=u"
      ],
      "metadata": {
        "id": "NelrdvVvmXPN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Compute relative l2 error\n",
        "error_s = np.linalg.norm(s_test - s_pred) / np.linalg.norm(s_test) \n",
        "error_u = np.linalg.norm(u_test[::P_test].flatten()[:,None] - s_y_pred) / np.linalg.norm(u_test[::P_test].flatten()[:,None]) "
      ],
      "metadata": {
        "id": "0-l8xC6cmjXv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(error_s,error_u)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T3OBppzUqMsa",
        "outputId": "5e3745ad-6d82-4d42-f33a-c5953fe911a9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.0019666823801816335 0.093285374\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Visualize the results for the first function in our Testing Dataset"
      ],
      "metadata": {
        "id": "os7XSd21Xj3l"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "idx=0\n",
        "index = np.arange(idx * P_test,(idx + 1) * P_test)"
      ],
      "metadata": {
        "id": "rxObn9b8sNFI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Compute the relative l2 error for one input sample \n",
        "error_u = np.linalg.norm(s_test[index, :] - s_pred[index, :], 2) / np.linalg.norm(s_test[index, :], 2) \n",
        "error_s = np.linalg.norm(u_test[::P_test][idx].flatten()[:,None] - s_y_pred[index, :], 2) / np.linalg.norm(u_test[::P_test][idx].flatten()[:,None], 2) \n",
        "\n",
        "print(\"error_u: {:.3e}\".format(error_u))\n",
        "print(\"error_s: {:.3e}\".format(error_s))\n",
        "\n",
        "# Visualizations\n",
        "# Predicted solution s(y)\n",
        "plt.figure(figsize=(12,5))\n",
        "plt.subplot(1,2,1)\n",
        "plt.plot(y_test[index, :], s_test[index, :], label='Exact s', lw=2)\n",
        "plt.plot(y_test[index, :], s_pred[index, :], '--', label='Predicted s', lw=2)\n",
        "plt.xlabel('y')\n",
        "plt.ylabel('s(y)')\n",
        "plt.tight_layout()\n",
        "plt.legend()\n",
        "\n",
        "plt.subplot(1,2,2)\n",
        "plt.plot(y_test[index, :], s_pred[index, :] - s_test[index, :], '--', lw=2, label='error')\n",
        "plt.tight_layout()\n",
        "plt.legend()\n",
        "plt.show()\n",
        "\n",
        "# Predicted residual u(x)\n",
        "fig = plt.figure(figsize=(12,5))\n",
        "plt.subplot(1,2,1)\n",
        "plt.plot(y_test[index, :], u_test[::P_test][idx], label='Exact u', lw=2)\n",
        "plt.plot(y_test[index, :], s_y_pred[index,:], '--', label='Predicted u', lw=2)\n",
        "plt.legend()\n",
        "plt.tight_layout()\n",
        "\n",
        "plt.subplot(1,2,2)\n",
        "plt.plot(y_test[index, :], s_y_pred[index,:].flatten() - u_test[::P_test][idx] , '--', label='error', lw=2)\n",
        "plt.legend()\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 723
        },
        "id": "IJs6uuFKsZav",
        "outputId": "2e60e6f8-6214-4a3e-d75a-646909c2d8a8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "error_u: 1.967e-03\n",
            "error_s: 9.329e-02\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 864x360 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 864x360 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Example"
      ],
      "metadata": {
        "id": "V2Tj3ENYAS1f"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Lets obtain the anti-derivative of a trigonometric function. **However**, remember that this neural operator works for $x\\in[0,1]$ when the antiderivative's initial value ($s(0)=0$). To fulfill that conditions, we will use $u(x)=cos(2\\pi x),∀x\\in[0,1]$.\n",
        "\n",
        "\n",
        "So, we will evaluate our operator ($G$):\n",
        "\n",
        "\n",
        "$$G:u(x)→s(x)=s(0)+\\int_{0}^{x}u(t)dt$$\n",
        "\n",
        "to $u(t)=cos(2\\pi t)$:\n",
        "\n",
        "$$s(x)=s(0)+\\int_{0}^{x}cos(2\\pi t)dt$$\n",
        "\n",
        "Since $s(0)=0$, the answer would be (the integral of u):\n",
        "\n",
        "$$s(x)=\\frac{1}{2\\pi}sin(2\\pi x)$$\n",
        "\n"
      ],
      "metadata": {
        "id": "I9D9TlZpXvVS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#u_fn = lambda x, t: np.interp(t, X.flatten(), gp_sample)\n",
        "u_fn = lambda t, x: -np.cos(2*np.pi*x)\n",
        "# Input sensor locations and measurements\n",
        "x = np.linspace(0, 1, m)\n",
        "u = u_fn(None,x)\n",
        "# Output sensor locations and measurements\n",
        "y =random.uniform(key_train, (m,)).sort()"
      ],
      "metadata": {
        "id": "uBbYSKUGAJU1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# reshapte the data to be processed by our DeepOnet\n",
        "u2=np.tile(u,100)\n",
        "u2=np.float32(u2.reshape(N_test * P_test,-1))\n",
        "y=y.reshape(len(y),1)"
      ],
      "metadata": {
        "id": "5FrbAxKkALIi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "s=model.predict_s(params, u2, y)[:,None]"
      ],
      "metadata": {
        "id": "Hg6jY2IbANDO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plot_us(x,u,y,s)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 406
        },
        "id": "J13kyBSwAO9X",
        "outputId": "53eb8cb2-da7c-43c3-f447-bae0c9b2e9c3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 576x432 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# References\n",
        "\n",
        "[1] Lu, L., Jin, P., & Karniadakis, G. E. (2019). Deeponet: Learning nonlinear operators for identifying differential equations based on the universal approximation theorem of operators. arXiv preprint arXiv:1910.03193.\n",
        "\n",
        "[2] Wang, S., Wang, H., & Perdikaris, P. (2021). Learning the solution operator of parametric partial differential equations with physics-informed DeepONets. Science advances, 7(40), eabi8605."
      ],
      "metadata": {
        "id": "hAmGDh9OfSQd"
      }
    }
  ]
}
